
import pandas as pd
import numpy as np
from datetime import datetime, timedelta
from matplotlib import pyplot as plt
import plotly.express as px


def data_full_info(dataset):
    print (dataset.info())
    return (dataset.head(10))


visits, orders, costs = (
    pd.read_csv('/datasets/visits_info_short.csv'),
    pd.read_csv('/datasets/orders_info_short.csv'),
    pd.read_csv('/datasets/costs_info_short.csv'),
)


data_full_info(visits)

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 309901 entries, 0 to 309900
Data columns (total 6 columns):
 #   Column         Non-Null Count   Dtype 
---  ------         --------------   ----- 
 0   User Id        309901 non-null  int64 
 1   Region         309901 non-null  object
 2   Device         309901 non-null  object
 3   Channel        309901 non-null  object
 4   Session Start  309901 non-null  object
 5   Session End    309901 non-null  object
dtypes: int64(1), object(5)
memory usage: 14.2+ MB
None


data_full_info(orders)

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 40212 entries, 0 to 40211
Data columns (total 3 columns):
 #   Column    Non-Null Count  Dtype  
---  ------    --------------  -----  
 0   User Id   40212 non-null  int64  
 1   Event Dt  40212 non-null  object 
 2   Revenue   40212 non-null  float64
dtypes: float64(1), int64(1), object(1)
memory usage: 942.6+ KB
None


data_full_info(costs)

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1800 entries, 0 to 1799
Data columns (total 3 columns):
 #   Column   Non-Null Count  Dtype  
---  ------   --------------  -----  
 0   dt       1800 non-null   object 
 1   Channel  1800 non-null   object 
 2   costs    1800 non-null   float64
dtypes: float64(1), object(2)
memory usage: 42.3+ KB
None


visits = visits.rename(columns=str.lower)
orders = orders.rename(columns=str.lower)
costs = costs.rename(columns=str.lower)


visits = visits.rename(columns={'user id': 'user_id', 'session start': 'session_start', 'session end': 'session_end'})


orders = orders.rename(columns={'user id': 'user_id', 'event dt': 'event_dt'})


visits.isna().sum()

user_id          0
region           0
device           0
channel          0
session_start    0
session_end      0
dtype: int64


orders.isna().sum()

user_id     0
event_dt    0
revenue     0
dtype: int64


costs.isna().sum()

dt         0
channel    0
costs      0
dtype: int64


visits.duplicated().sum()

0


orders.duplicated().sum()

0


costs.duplicated().sum()

0


display('Регионы', visits['region'].unique())
display('Каналы', visits['channel'].unique())
display('Устройства', visits['device'].unique())

'Регионы'

array(['United States', 'UK', 'France', 'Germany'], dtype=object)

'Каналы'

array(['organic', 'TipTop', 'RocketSuperAds', 'YRabbit', 'FaceBoom',
       'MediaTornado', 'AdNonSense', 'LeapBob', 'WahooNetBanner',
       'OppleCreativeMedia', 'lambdaMediaAds'], dtype=object)

'Устройства'

array(['iPhone', 'Mac', 'Android', 'PC'], dtype=object)


display('Каналы', costs['channel'].unique())

'Каналы'

array(['FaceBoom', 'MediaTornado', 'RocketSuperAds', 'TipTop', 'YRabbit',
       'AdNonSense', 'LeapBob', 'OppleCreativeMedia', 'WahooNetBanner',
       'lambdaMediaAds'], dtype=object)


visits['session_start'] = pd.to_datetime(visits['session_start'])
visits['session_end'] = pd.to_datetime(visits['session_end'])
orders['event_dt'] = pd.to_datetime(orders['event_dt'])
costs['dt'] = pd.to_datetime(costs['dt']).dt.date


# функция для получения пользовательских профилей
def get_profiles(sessions, orders, ad_costs):
    profiles = (
        sessions.sort_values(by=['user_id', 'session_start'])
        .groupby('user_id')
        .agg(
            {
                'session_start': 'first',
                'channel': 'first',
                'device': 'first',
                'region': 'first',
            }
        )
        .rename(columns={'session_start': 'first_ts'})
        .reset_index()
    )
    profiles['dt'] = profiles['first_ts'].dt.date
    profiles['month'] = profiles['first_ts'].astype('datetime64[M]')
    profiles['payer'] = profiles['user_id'].isin(orders['user_id'].unique())

    new_users = (
        profiles.groupby(['dt', 'channel'])
        .agg({'user_id': 'nunique'})
        .rename(columns={'user_id': 'unique_users'})
        .reset_index()
    )
    ad_costs = ad_costs.merge(new_users, on=['dt', 'channel'], how='left')
    ad_costs['acquisition_cost'] = ad_costs['costs'] / ad_costs['unique_users']
    profiles = profiles.merge(
        ad_costs[['dt', 'channel', 'acquisition_cost']],
        on=['dt', 'channel'],
        how='left',
    )
    profiles['acquisition_cost'] = profiles['acquisition_cost'].fillna(0)

    return profiles


# функция для расчёта удержания

def get_retention(
    profiles,
    sessions,
    observation_date,
    horizon_days,
    dimensions=[],
    ignore_horizon=False,
):

    # добавляем столбец payer в передаваемый dimensions список
    dimensions = ['payer'] + dimensions

    # исключаем пользователей, не «доживших» до горизонта анализа
    last_suitable_acquisition_date = observation_date
    if not ignore_horizon:
        last_suitable_acquisition_date = observation_date - timedelta(
            days=horizon_days - 1
        )
    result_raw = profiles.query('dt <= @last_suitable_acquisition_date')

    # собираем «сырые» данные для расчёта удержания
    result_raw = result_raw.merge(
        sessions[['user_id', 'session_start']], on='user_id', how='left'
    )
    result_raw['lifetime'] = (
        result_raw['session_start'] - result_raw['first_ts']
    ).dt.days

    # функция для группировки таблицы по желаемым признакам
    def group_by_dimensions(df, dims, horizon_days):
        result = df.pivot_table(
            index=dims, columns='lifetime', values='user_id', aggfunc='nunique'
        )
        cohort_sizes = (
            df.groupby(dims)
            .agg({'user_id': 'nunique'})
            .rename(columns={'user_id': 'cohort_size'})
        )
        result = cohort_sizes.merge(result, on=dims, how='left').fillna(0)
        result = result.div(result['cohort_size'], axis=0)
        result = result[['cohort_size'] + list(range(horizon_days))]
        result['cohort_size'] = cohort_sizes
        return result

    # получаем таблицу удержания
    result_grouped = group_by_dimensions(result_raw, dimensions, horizon_days)

    # получаем таблицу динамики удержания
    result_in_time = group_by_dimensions(
        result_raw, dimensions + ['dt'], horizon_days
    )

    # возвращаем обе таблицы и сырые данные
    return result_raw, result_grouped, result_in_time


# функция для расчёта конверсии

def get_conversion(
    profiles,
    purchases,
    observation_date,
    horizon_days,
    dimensions=[],
    ignore_horizon=False,
):

    # исключаем пользователей, не «доживших» до горизонта анализа
    last_suitable_acquisition_date = observation_date
    if not ignore_horizon:
        last_suitable_acquisition_date = observation_date - timedelta(
            days=horizon_days - 1
        )
    result_raw = profiles.query('dt <= @last_suitable_acquisition_date')

    # определяем дату и время первой покупки для каждого пользователя
    first_purchases = (
        purchases.sort_values(by=['user_id', 'event_dt'])
        .groupby('user_id')
        .agg({'event_dt': 'first'})
        .reset_index()
    )

    # добавляем данные о покупках в профили
    result_raw = result_raw.merge(
        first_purchases[['user_id', 'event_dt']], on='user_id', how='left'
    )

    # рассчитываем лайфтайм для каждой покупки
    result_raw['lifetime'] = (
        result_raw['event_dt'] - result_raw['first_ts']
    ).dt.days

    # группируем по cohort, если в dimensions ничего нет
    if len(dimensions) == 0:
        result_raw['cohort'] = 'All users' 
        dimensions = dimensions + ['cohort']

    # функция для группировки таблицы по желаемым признакам
    def group_by_dimensions(df, dims, horizon_days):
        result = df.pivot_table(
            index=dims, columns='lifetime', values='user_id', aggfunc='nunique'
        )
        result = result.fillna(0).cumsum(axis = 1)
        cohort_sizes = (
            df.groupby(dims)
            .agg({'user_id': 'nunique'})
            .rename(columns={'user_id': 'cohort_size'})
        )
        result = cohort_sizes.merge(result, on=dims, how='left').fillna(0)
        # делим каждую «ячейку» в строке на размер когорты
        # и получаем conversion rate
        result = result.div(result['cohort_size'], axis=0)
        result = result[['cohort_size'] + list(range(horizon_days))]
        result['cohort_size'] = cohort_sizes
        return result

    # получаем таблицу конверсии
    result_grouped = group_by_dimensions(result_raw, dimensions, horizon_days)

    # для таблицы динамики конверсии убираем 'cohort' из dimensions
    if 'cohort' in dimensions: 
        dimensions = []

    # получаем таблицу динамики конверсии
    result_in_time = group_by_dimensions(
        result_raw, dimensions + ['dt'], horizon_days
    )

    # возвращаем обе таблицы и сырые данные
    return result_raw, result_grouped, result_in_time


# функция для расчёта LTV и ROI

def get_ltv(
    profiles,
    purchases,
    observation_date,
    horizon_days,
    dimensions=[],
    ignore_horizon=False,
):

    # исключаем пользователей, не «доживших» до горизонта анализа
    last_suitable_acquisition_date = observation_date
    if not ignore_horizon:
        last_suitable_acquisition_date = observation_date - timedelta(
            days=horizon_days - 1
        )
    result_raw = profiles.query('dt <= @last_suitable_acquisition_date')
    # добавляем данные о покупках в профили
    result_raw = result_raw.merge(
        purchases[['user_id', 'event_dt', 'revenue']], on='user_id', how='left'
    )
    # рассчитываем лайфтайм пользователя для каждой покупки
    result_raw['lifetime'] = (
        result_raw['event_dt'] - result_raw['first_ts']
    ).dt.days
    # группируем по cohort, если в dimensions ничего нет
    if len(dimensions) == 0:
        result_raw['cohort'] = 'All users'
        dimensions = dimensions + ['cohort']

    # функция группировки по желаемым признакам
    def group_by_dimensions(df, dims, horizon_days):
        # строим «треугольную» таблицу выручки
        result = df.pivot_table(
            index=dims, columns='lifetime', values='revenue', aggfunc='sum'
        )
        # находим сумму выручки с накоплением
        result = result.fillna(0).cumsum(axis=1)
        # вычисляем размеры когорт
        cohort_sizes = (
            df.groupby(dims)
            .agg({'user_id': 'nunique'})
            .rename(columns={'user_id': 'cohort_size'})
        )
        # объединяем размеры когорт и таблицу выручки
        result = cohort_sizes.merge(result, on=dims, how='left').fillna(0)
        # считаем LTV: делим каждую «ячейку» в строке на размер когорты
        result = result.div(result['cohort_size'], axis=0)
        # исключаем все лайфтаймы, превышающие горизонт анализа
        result = result[['cohort_size'] + list(range(horizon_days))]
        # восстанавливаем размеры когорт
        result['cohort_size'] = cohort_sizes

        # собираем датафрейм с данными пользователей и значениями CAC, 
        # добавляя параметры из dimensions
        cac = df[['user_id', 'acquisition_cost'] + dims].drop_duplicates()

        # считаем средний CAC по параметрам из dimensions
        cac = (
            cac.groupby(dims)
            .agg({'acquisition_cost': 'mean'})
            .rename(columns={'acquisition_cost': 'cac'})
        )

        # считаем ROI: делим LTV на CAC
        roi = result.div(cac['cac'], axis=0)

        # удаляем строки с бесконечным ROI
        roi = roi[~roi['cohort_size'].isin([np.inf])]

        # восстанавливаем размеры когорт в таблице ROI
        roi['cohort_size'] = cohort_sizes

        # добавляем CAC в таблицу ROI
        roi['cac'] = cac['cac']

        # в финальной таблице оставляем размеры когорт, CAC
        # и ROI в лайфтаймы, не превышающие горизонт анализа
        roi = roi[['cohort_size', 'cac'] + list(range(horizon_days))]

        # возвращаем таблицы LTV и ROI
        return result, roi

    # получаем таблицы LTV и ROI
    result_grouped, roi_grouped = group_by_dimensions(
        result_raw, dimensions, horizon_days
    )

    # для таблиц динамики убираем 'cohort' из dimensions
    if 'cohort' in dimensions:
        dimensions = []

    # получаем таблицы динамики LTV и ROI
    result_in_time, roi_in_time = group_by_dimensions(
        result_raw, dimensions + ['dt'], horizon_days
    )

    return (
        result_raw,  # сырые данные
        result_grouped,  # таблица LTV
        result_in_time,  # таблица динамики LTV
        roi_grouped,  # таблица ROI
        roi_in_time,  # таблица динамики ROI
    )


# функция для сглаживания фрейма

def filter_data(df, window):
    # для каждого столбца применяем скользящее среднее
    for column in df.columns.values:
        df[column] = df[column].rolling(window).mean() 
    return df


# функция для визуализации удержания

def plot_retention(retention, retention_history, horizon, window=7):

    # задаём размер сетки для графиков
    plt.figure(figsize=(15, 10))

    # исключаем размеры когорт и удержание первого дня
    retention = retention.drop(columns=['cohort_size', 0])
    # в таблице динамики оставляем только нужный лайфтайм
    retention_history = retention_history.drop(columns=['cohort_size'])[
        [horizon - 1]
    ]

    # если в индексах таблицы удержания только payer,
    # добавляем второй признак — cohort
    if retention.index.nlevels == 1:
        retention['cohort'] = 'All users'
        retention = retention.reset_index().set_index(['cohort', 'payer'])

    # в таблице графиков — два столбца и две строки, четыре ячейки
    # в первой строим кривые удержания платящих пользователей
    ax1 = plt.subplot(2, 2, 1)
    retention.query('payer == True').droplevel('payer').T.plot(
        grid=True, ax=ax1
    )
    plt.legend()
    plt.xlabel('Лайфтайм')
    plt.title('Удержание платящих пользователей')

    # во второй ячейке строим кривые удержания неплатящих
    # вертикальная ось — от графика из первой ячейки
    ax2 = plt.subplot(2, 2, 2, sharey=ax1)
    retention.query('payer == False').droplevel('payer').T.plot(
        grid=True, ax=ax2
    )
    plt.legend()
    plt.xlabel('Лайфтайм')
    plt.title('Удержание неплатящих пользователей')

    # в третьей ячейке — динамика удержания платящих
    ax3 = plt.subplot(2, 2, 3)
    # получаем названия столбцов для сводной таблицы
    columns = [
        name
        for name in retention_history.index.names
        if name not in ['dt', 'payer']
    ]
    # фильтруем данные и строим график
    filtered_data = retention_history.query('payer == True').pivot_table(
        index='dt', columns=columns, values=horizon - 1, aggfunc='mean'
    )
    filter_data(filtered_data, window).plot(grid=True, ax=ax3)
    plt.xlabel('Дата привлечения')
    plt.title(
        'Динамика удержания платящих пользователей на {}-й день'.format(
            horizon
        )
    )

    # в чётвертой ячейке — динамика удержания неплатящих
    ax4 = plt.subplot(2, 2, 4, sharey=ax3)
    # фильтруем данные и строим график
    filtered_data = retention_history.query('payer == False').pivot_table(
        index='dt', columns=columns, values=horizon - 1, aggfunc='mean'
    )
    filter_data(filtered_data, window).plot(grid=True, ax=ax4)
    plt.xlabel('Дата привлечения')
    plt.title(
        'Динамика удержания неплатящих пользователей на {}-й день'.format(
            horizon
        )
    )
    
    plt.tight_layout()
    plt.show()


# функция для визуализации конверсии

def plot_conversion(conversion, conversion_history, horizon, window=7):

    # задаём размер сетки для графиков
    plt.figure(figsize=(15, 5))

    # исключаем размеры когорт
    conversion = conversion.drop(columns=['cohort_size'])
    # в таблице динамики оставляем только нужный лайфтайм
    conversion_history = conversion_history.drop(columns=['cohort_size'])[
        [horizon - 1]
    ]

    # первый график — кривые конверсии
    ax1 = plt.subplot(1, 2, 1)
    conversion.T.plot(grid=True, ax=ax1)
    plt.legend()
    plt.xlabel('Лайфтайм')
    plt.title('Конверсия пользователей')

    # второй график — динамика конверсии
    ax2 = plt.subplot(1, 2, 2, sharey=ax1)
    columns = [
        # столбцами сводной таблицы станут все столбцы индекса, кроме даты
        name for name in conversion_history.index.names if name not in ['dt']
    ]
    filtered_data = conversion_history.pivot_table(
        index='dt', columns=columns, values=horizon - 1, aggfunc='mean'
    )
    filter_data(filtered_data, window).plot(grid=True, ax=ax2)
    plt.xlabel('Дата привлечения')
    plt.title('Динамика конверсии пользователей на {}-й день'.format(horizon))

    plt.tight_layout()
    plt.show()


# функция для визуализации LTV и ROI

def plot_ltv_roi(ltv, ltv_history, roi, roi_history, horizon, window=7):

    # задаём сетку отрисовки графиков
    plt.figure(figsize=(20, 10))

    # из таблицы ltv исключаем размеры когорт
    ltv = ltv.drop(columns=['cohort_size'])
    # в таблице динамики ltv оставляем только нужный лайфтайм
    ltv_history = ltv_history.drop(columns=['cohort_size'])[[horizon - 1]]

    # стоимость привлечения запишем в отдельный фрейм
    cac_history = roi_history[['cac']]

    # из таблицы roi исключаем размеры когорт и cac
    roi = roi.drop(columns=['cohort_size', 'cac'])
    # в таблице динамики roi оставляем только нужный лайфтайм
    roi_history = roi_history.drop(columns=['cohort_size', 'cac'])[
        [horizon - 1]
    ]

    # первый график — кривые ltv
    ax1 = plt.subplot(2, 3, 1)
    ltv.T.plot(grid=True, ax=ax1)
    plt.legend()
    plt.xlabel('Лайфтайм')
    plt.title('LTV')

    # второй график — динамика ltv
    ax2 = plt.subplot(2, 3, 2, sharey=ax1)
    # столбцами сводной таблицы станут все столбцы индекса, кроме даты
    columns = [name for name in ltv_history.index.names if name not in ['dt']]
    filtered_data = ltv_history.pivot_table(
        index='dt', columns=columns, values=horizon - 1, aggfunc='mean'
    )
    filter_data(filtered_data, window).plot(grid=True, ax=ax2)
    plt.xlabel('Дата привлечения')
    plt.title('Динамика LTV пользователей на {}-й день'.format(horizon))

    # третий график — динамика cac
    ax3 = plt.subplot(2, 3, 3, sharey=ax1)
    # столбцами сводной таблицы станут все столбцы индекса, кроме даты
    columns = [name for name in cac_history.index.names if name not in ['dt']]
    filtered_data = cac_history.pivot_table(
        index='dt', columns=columns, values='cac', aggfunc='mean'
    )
    filter_data(filtered_data, window).plot(grid=True, ax=ax3)
    plt.xlabel('Дата привлечения')
    plt.title('Динамика стоимости привлечения пользователей')

    # четвёртый график — кривые roi
    ax4 = plt.subplot(2, 3, 4)
    roi.T.plot(grid=True, ax=ax4)
    plt.axhline(y=1, color='red', linestyle='--', label='Уровень окупаемости')
    plt.legend()
    plt.xlabel('Лайфтайм')
    plt.title('ROI')

    # пятый график — динамика roi
    ax5 = plt.subplot(2, 3, 5, sharey=ax4)
    # столбцами сводной таблицы станут все столбцы индекса, кроме даты
    columns = [name for name in roi_history.index.names if name not in ['dt']]
    filtered_data = roi_history.pivot_table(
        index='dt', columns=columns, values=horizon - 1, aggfunc='mean'
    )
    filter_data(filtered_data, window).plot(grid=True, ax=ax5)
    plt.axhline(y=1, color='red', linestyle='--', label='Уровень окупаемости')
    plt.xlabel('Дата привлечения')
    plt.title('Динамика ROI пользователей на {}-й день'.format(horizon))

    plt.tight_layout()
    plt.show()


profiles = get_profiles(visits, orders, costs)

display(profiles.head(), profiles.tail())


min_date = profiles['dt'].min()
max_date = profiles['dt'].max()
print(f'Минимальная дата привлечения пользователей {min_date}')
print(f'Максимальная дата привлечения пользователей {max_date}')

Минимальная дата привлечения пользователей 2019-05-01
Максимальная дата привлечения пользователей 2019-10-27


def create_pivot_table(data, index, columns, values):
    pivot_table = pd.pivot_table(data, index=index, columns=columns, values=values, aggfunc='count') \
                 .rename(columns={True: 'payer', False: 'not_payer'}) \
                 .sort_values('payer', ascending=False)
    pivot_table['share'] = (pivot_table['payer'] / (pivot_table['payer'] + pivot_table['not_payer'])) * 100
    pivot_table = pivot_table.sort_values(by='share', ascending=False).style.format({'share': '{:.2f}%'})
    return pivot_table


def for_chart(data, index, columns, values):
    pivot_table = pd.pivot_table(data, index=index, columns=columns, values=values, aggfunc='count') \
                 .rename(columns={True: 'payer', False: 'not_payer'}) \
                 .sort_values('payer', ascending=False)
    return pivot_table


display(create_pivot_table(profiles, 'region','payer', 'user_id'))
fig = px.bar(for_chart(profiles, 'region','payer', 'user_id'),
            template='plotly_white', title='Распределение пользователей по странам',
              labels=dict(region="регион", value="количество пользователей", variable="тип пользователя"))
fig.show()


display(create_pivot_table(profiles, 'device','payer', 'user_id'))
fig = px.bar(for_chart(profiles, 'device','payer', 'user_id'),
            template='plotly_white', title='Распределение пользователей по устройствам',
              labels=dict(device="device", value="количество пользователей", variable="тип пользователя"))
fig.show()


display(create_pivot_table(profiles, 'channel','payer', 'user_id'))
fig = px.bar(for_chart(profiles, 'channel','payer', 'user_id'),
            template='plotly_white', title='Распределение пользователей по каналам',
              labels=dict(channel="channel", value="количество пользователей", variable="тип пользователя"))
fig.show()


sum_costs = costs['costs'].sum().round()
print(f'Общая сумма расходов на маркетинг {sum_costs}')

Общая сумма расходов на маркетинг 105497.0


channel_costs = costs.pivot_table(index='channel', values='costs', aggfunc='sum').sort_values('costs', ascending=False)
channel_costs_fig = px.bar(channel_costs,
            template='plotly_white', title='Траты на рекламные источники',
              labels=dict(channel="канал", value="сумма"))
channel_costs_fig.show()
channel_costs['share'] = channel_costs['costs'] / channel_costs['costs'].sum() * 100
channel_costs.style.format({'share': '{:.2f}%'})


fig = px.line(costs.pivot_table(index='dt', values='costs', aggfunc='sum', columns='channel'),
              template='plotly_white', title='Затраты на привлечение пользователей по каналам',
              labels=dict(dt="дата", value="затраты на привлечение в день", channel="каналы"))
fig.show()


costs['dt'] = pd.to_datetime(costs['dt'])
costs['month'] = costs['dt'].dt.month
costs['week'] = costs['dt'].dt.week

/tmp/ipykernel_160/1723762270.py:3: FutureWarning:

Series.dt.weekofyear and Series.dt.week have been deprecated.  Please use Series.dt.isocalendar().week instead.


plt.figure(figsize=(20, 7))

week_costs = costs.pivot_table(index='channel', columns='week', values='costs', aggfunc='sum')
week_costs.T.plot(grid=True, xticks=list(week_costs.columns.values), ax=plt.subplot(1, 2, 1))
plt.title('Динамика расходов по неделям')

month_costs = costs.pivot_table(index='channel', columns='month', values='costs', aggfunc='sum')
month_costs.T.plot(grid=True, xticks=list(month_costs.columns.values), ax=plt.subplot(1, 2, 2))
plt.title('Динамика расходов по неделям')

plt.show()


cac = profiles.query('channel != "organic"')[['user_id', 'acquisition_cost']].agg({'acquisition_cost':'mean'})
cac

acquisition_cost    1.127481
dtype: float64


cac_channel = profiles.pivot_table(index='channel', values='acquisition_cost', aggfunc='mean') \
                      .sort_values(by='acquisition_cost', ascending=False) \
                      .rename(columns={'acquisition_cost':'cac'})
display(cac_channel.style.format({'cac': '{:.2f}'}))
fig = px.bar(cac_channel,
            template='plotly_white', title='Стоимость привлечения пользователей по каналам',
              labels=dict(channel="канал", value="сумма"))
fig.show();


profiles = profiles.query('channel != "organic"')


observation_date = datetime(2019, 11, 1).date()
analysis_horizon = 14


ltv_raw, ltv_grouped, ltv_history, roi_grouped, roi_history = get_ltv(profiles, orders, \
                                                                      observation_date, analysis_horizon)

plot_ltv_roi(ltv_grouped, ltv_history, roi_grouped, roi_history, analysis_horizon)


conversion_raw, conversion, conversion_history = get_conversion(
    profiles,
    orders,
    observation_date,
    analysis_horizon,
)
plot_conversion(conversion, conversion_history, analysis_horizon)


retention_raw, retention_grouped, retention_history = get_retention(
    profiles, 
    visits, 
    observation_date, 
    analysis_horizon,
)
plot_retention(retention_grouped, retention_history, analysis_horizon)


dimensions=['device']


ltv_raw, ltv_grouped, ltv_history, roi_grouped, roi_history = get_ltv(profiles, orders, \
                                                                      observation_date, analysis_horizon, dimensions
                                                                     )

plot_ltv_roi(ltv_grouped, ltv_history, roi_grouped, roi_history, analysis_horizon)


retention_raw, retention_grouped, retention_history = get_retention(
    profiles, 
    visits, 
    observation_date, 
    analysis_horizon,
    dimensions
)
plot_retention(retention_grouped, retention_history, analysis_horizon)


conversion_raw, conversion, conversion_history = get_conversion(
    profiles,
    orders,
    observation_date,
    analysis_horizon,
    dimensions
)
plot_conversion(conversion, conversion_history, analysis_horizon)


dimensions=['region']

ltv_raw, ltv_grouped, ltv_history, roi_grouped, roi_history = get_ltv(profiles, orders, \
                                                                      observation_date, analysis_horizon, dimensions
                                                                     )
plot_ltv_roi(ltv_grouped, ltv_history, roi_grouped, roi_history, analysis_horizon)


retention_raw, retention_grouped, retention_history = get_retention(
    profiles, 
    visits, 
    observation_date, 
    analysis_horizon,
    dimensions
)
plot_retention(retention_grouped, retention_history, analysis_horizon)


conversion_raw, conversion, conversion_history = get_conversion(
    profiles,
    orders,
    observation_date,
    analysis_horizon,
    dimensions
)
plot_conversion(conversion, conversion_history, analysis_horizon)


dimensions=['channel']


ltv_raw, ltv_grouped, ltv_history, roi_grouped, roi_history = get_ltv(profiles, orders, \
                                                                      observation_date, analysis_horizon, dimensions
                                                                     )

plot_ltv_roi(ltv_grouped, ltv_history, roi_grouped, roi_history, analysis_horizon)


retention_raw, retention_grouped, retention_history = get_retention(
    profiles, 
    visits, 
    observation_date, 
    analysis_horizon,
    dimensions
)
plot_retention(retention_grouped, retention_history, analysis_horizon)


conversion_raw, conversion, conversion_history = get_conversion(
    profiles,
    orders,
    observation_date,
    analysis_horizon,
    dimensions
)
plot_conversion(conversion, conversion_history, analysis_horizon)


profiles_usa = profiles.query('region == "United States"')
profiles_others = profiles.query('region != "United States"')


ltv_raw, ltv_grouped, ltv_history, roi_grouped, roi_history = get_ltv(profiles_usa, 
                                                                      orders, 
                                                                      observation_date, 
                                                                      analysis_horizon,
                                                                      dimensions 
                                                                     )
plot_ltv_roi(ltv_grouped, ltv_history, roi_grouped, roi_history, analysis_horizon)


retention_raw, retention_grouped, retention_history = get_retention(
    profiles_usa, 
    visits, 
    observation_date, 
    analysis_horizon,
    dimensions
)
plot_retention(retention_grouped, retention_history, analysis_horizon)


conversion_raw, conversion, conversion_history = get_conversion(
    profiles_usa,
    orders,
    observation_date,
    analysis_horizon,
    dimensions
)
plot_conversion(conversion, conversion_history, analysis_horizon)


ltv_raw, ltv_grouped, ltv_history, roi_grouped, roi_history = get_ltv(profiles_others, 
                                                                      orders, 
                                                                      observation_date, 
                                                                      analysis_horizon,
                                                                      dimensions 
                                                                     )
plot_ltv_roi(ltv_grouped, ltv_history, roi_grouped, roi_history, analysis_horizon)


retention_raw, retention_grouped, retention_history = get_retention(
    profiles_others, 
    visits, 
    observation_date, 
    analysis_horizon,
    dimensions
)
plot_retention(retention_grouped, retention_history, analysis_horizon)


conversion_raw, conversion, conversion_history = get_conversion(
    profiles_others,
    orders,
    observation_date,
    analysis_horizon,
    dimensions
)
plot_conversion(conversion, conversion_history, analysis_horizon)

	User Id	Event Dt	Revenue
0	188246423999	2019-05-01 23:09:52	4.99
1	174361394180	2019-05-01 12:24:04	4.99
2	529610067795	2019-05-01 11:34:04	4.99
3	319939546352	2019-05-01 15:34:40	4.99
4	366000285810	2019-05-01 13:59:51	4.99
5	129100331057	2019-05-01 01:56:28	4.99
6	626807144131	2019-05-01 02:39:21	4.99
7	914062168985	2019-05-01 02:02:18	4.99
8	769669137453	2019-05-01 03:39:47	4.99
9	434198630691	2019-05-01 18:16:50	5.99

	dt	Channel	costs
0	2019-05-01	FaceBoom	113.3
1	2019-05-02	FaceBoom	78.1
2	2019-05-03	FaceBoom	85.8
3	2019-05-04	FaceBoom	136.4
4	2019-05-05	FaceBoom	122.1
5	2019-05-06	FaceBoom	118.8
6	2019-05-07	FaceBoom	101.2
7	2019-05-08	FaceBoom	100.1
8	2019-05-09	FaceBoom	93.5
9	2019-05-10	FaceBoom	104.5

	user_id	first_ts	channel	device	region	dt	month	payer	acquisition_cost
150003	999956196527	2019-09-28 08:33:02	TipTop	iPhone	United States	2019-09-28	2019-09-01	False	3.500000
150004	999975439887	2019-10-21 00:35:17	organic	PC	UK	2019-10-21	2019-10-01	False	0.000000
150005	999976332130	2019-07-23 02:57:06	TipTop	iPhone	United States	2019-07-23	2019-07-01	False	2.600000
150006	999979924135	2019-09-28 21:28:09	MediaTornado	PC	United States	2019-09-28	2019-09-01	False	0.205714
150007	999999563947	2019-10-18 19:57:25	organic	iPhone	United States	2019-10-18	2019-10-01	False	0.000000

payer	not_payer	payer	share
region
United States	93100	6902	6.90%
Germany	14365	616	4.11%
UK	16875	700	3.98%
France	16787	663	3.80%

payer	not_payer	payer	share
device
Mac	28130	1912	6.36%
iPhone	51097	3382	6.21%
Android	32982	2050	5.85%
PC	28918	1537	5.05%

Анализ бизнес-показателей приложения Procrastinate Pro+¶

Загрузите данные и подготовьте их к анализу¶

Задайте функции для расчёта и анализа LTV, ROI, удержания и конверсии.¶

Исследовательский анализ данных¶

Маркетинг¶

Оцените окупаемость рекламы¶

Напишите выводы¶

	User Id	Region	Device	Channel	Session Start	Session End
0	981449118918	United States	iPhone	organic	2019-05-01 02:36:01	2019-05-01 02:45:01
1	278965908054	United States	iPhone	organic	2019-05-01 04:46:31	2019-05-01 04:47:35
2	590706206550	United States	Mac	organic	2019-05-01 14:09:25	2019-05-01 15:32:08
3	326433527971	United States	Android	TipTop	2019-05-01 00:29:59	2019-05-01 00:54:25
4	349773784594	United States	Mac	organic	2019-05-01 03:33:35	2019-05-01 03:57:40
5	90242400005	United States	iPhone	RocketSuperAds	2019-05-01 07:14:52	2019-05-01 08:19:56
6	43958116050	United States	Android	organic	2019-05-01 09:03:21	2019-05-01 10:08:39
7	185365244969	United States	iPhone	organic	2019-05-01 09:37:03	2019-05-01 10:00:43
8	446013509831	United States	iPhone	RocketSuperAds	2019-05-01 10:26:00	2019-05-01 10:59:17
9	100970711362	United States	Mac	TipTop	2019-05-01 04:39:53	2019-05-01 04:57:05

	user_id	first_ts	channel	device	region	dt	month	payer	acquisition_cost
0	599326	2019-05-07 20:58:57	FaceBoom	Mac	United States	2019-05-07	2019-05-01	True	1.088172
1	4919697	2019-07-09 12:46:07	FaceBoom	iPhone	United States	2019-07-09	2019-07-01	False	1.107237
2	6085896	2019-10-01 09:58:33	organic	iPhone	France	2019-10-01	2019-10-01	False	0.000000
3	22593348	2019-08-22 21:35:48	AdNonSense	PC	Germany	2019-08-22	2019-08-01	False	0.988235
4	31989216	2019-10-02 00:07:44	YRabbit	iPhone	United States	2019-10-02	2019-10-01	False	0.230769

payer	not_payer	payer	share
channel
FaceBoom	25587	3557	12.20%
AdNonSense	3440	440	11.34%
lambdaMediaAds	1924	225	10.47%
TipTop	17683	1878	9.60%
RocketSuperAds	4096	352	7.91%
WahooNetBanner	8100	453	5.30%
YRabbit	4147	165	3.83%
MediaTornado	4208	156	3.57%
LeapBob	8291	262	3.06%
OppleCreativeMedia	8372	233	2.71%
organic	55279	1160	2.06%

	costs	share
channel
TipTop	54751.300000	51.90%
FaceBoom	32445.600000	30.75%
WahooNetBanner	5151.000000	4.88%
AdNonSense	3911.250000	3.71%
OppleCreativeMedia	2151.250000	2.04%
RocketSuperAds	1833.000000	1.74%
LeapBob	1797.600000	1.70%
lambdaMediaAds	1557.600000	1.48%
MediaTornado	954.480000	0.90%
YRabbit	944.220000	0.90%

	cac
channel
TipTop	2.80
FaceBoom	1.11
AdNonSense	1.01
lambdaMediaAds	0.72
WahooNetBanner	0.60
RocketSuperAds	0.41
OppleCreativeMedia	0.25
YRabbit	0.22
MediaTornado	0.22
LeapBob	0.21
organic	0.00